package com.framework.foundation.system.user;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;

import com.framework.foundation.common.BaseService;
import com.framework.foundation.common.ConstantResult;
import com.framework.foundation.common.vo.BTResult;
import com.framework.foundation.common.vo.IResult;
import com.framework.foundation.common.vo.Result;
import com.framework.foundation.util.Digests;
import com.framework.foundation.util.Encodes;
import com.jfinal.aop.Before;
import com.jfinal.aop.Enhancer;
import com.jfinal.core.Controller;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.Page;
import com.jfinal.plugin.activerecord.Record;
import com.jfinal.plugin.activerecord.tx.Tx;

public class UserService extends BaseService<User> {

	public static final UserService me = Enhancer.enhance(UserService.class);

	/**
	 * 用户登陆
	 * 
	 * @param username 用户名
	 * @param password 明文密码
	 * @param authCode 验证码
	 * @param controller 控制器
	 * @return 结果对象
	 * @Author: Brin
	 * @Date: 2015年10月20日 下午2:27:19
	 */
	public IResult<Object> login(String username, String password, String authCode, Controller controller) {
		try {
			// 1. 验证用户名和密码是否正确
			// 1.1 根据用户名获取用户
			User user = User.me.findFirst("SELECT * FROM ww_user WHERE username = ?", username);
			boolean flag = false;
			if (null != user) {
				// 1.2 根据明文密码和盐值进行加密
				byte[] encryptedPassword = Encodes.decodeHex(user.getStr("password"));
				byte[] encryptedAttemptedPassword = Digests.sha1(password.getBytes(), user.getStr("salt").getBytes(),
						1024);
				flag = Arrays.equals(encryptedPassword, encryptedAttemptedPassword);
			}
			// 用户名或密码错误
			if (!flag) {
				return Result.create(ConstantResult.LOGIN_CODE_1);
			}
			// // 2. 验证验证码是否正确
			// if (!CaptchaRender.validate(controller, authCode.toUpperCase(), Constant.ADMIN_AUTHCODE_KEY)) {
			// return Result.create(ConstantResult.LOGIN_CODE_2);
			// }
			return Result.createSuccess(user);
		} catch (Exception e) {
			throw new RuntimeException("用户登陆异常！", e);
		}
	}

	/**
	 * 新增方法
	 * 
	 * @param user
	 * @return
	 * @Author: Brin
	 * @Date: 2015年11月10日 下午1:58:08
	 */
	@Override
	public IResult<Object> save(User model) {
		try {
			if (null == model) {
				return Result.createFail(model);
			}
			encryptedPassword(model);
			return Result.create(model.save(), model);
		} catch (Exception e) {
			throw new RuntimeException("新增异常！", e);
		}
	}

	/**
	 * 编辑方法
	 * 
	 * @param user
	 * @return
	 * @Author: Brin
	 * @Date: 2015年11月10日 下午1:58:08
	 */
	@Override
	public IResult<Object> update(User model) {
		try {
			if (null == model) {
				return Result.createFail(model);
			}
			// 如果明文密码和加密后的一致则表示用户没有修改密码，此处则不需要修改密码
			User current = User.me.findById(model.get("id"));
			if (!current.getStr("password").equals(model.getStr("password"))) {
				encryptedPassword(model);
			}
			return Result.create(model.update(), model);
		} catch (Exception e) {
			throw new RuntimeException("编辑异常！", e);
		}
	}

	/**
	 * bootstraptable分页查询<br>
	 * 
	 * 基本参数:<br>
	 * pageNumber 第几页<br>
	 * pageSize 每页显示多少条记录<br>
	 * sortName 排序列名<br>
	 * sortOrder 排序类型<br>
	 * 
	 * 自定义参数:<br>
	 * enabled 状态(启用,禁用)
	 * lastVisitStart 最后登陆开始时间
	 * lastVisitEnd 最后登陆结束时间
	 * searchType 关键字对应的类型(如:用户名,姓名等)<br>
	 * searchKeywords 关键字<br>
	 * 
	 * @param param 请求参数
	 * @return
	 * @Author: Brin
	 * @Date: 2015年11月2日 上午10:52:11
	 */
	@Override
	public BTResult<Record> paginate(Map<String, Object> param) {
		StringBuffer select = new StringBuffer("SELECT u.id as id, u.username as username, u.realname as realname,");
		select.append("u.mobile as mobile, u.email as email, u.birthday as birthday, u.gender as gender,");
		select.append("u.logOnCount as logOnCount, u.ipAddress as ipAddress, u.macAddress as macAddress,");
		select.append("u.remark as remark, u.previousVisit as previousVisit, u.lastVisit as lastVisit,");
		select.append("u.enabled as enabled, u.sort as sort, u.type as type");

		StringBuffer from = new StringBuffer("FROM ww_user as u WHERE u.deleteMark = 0 ORDER BY u.id DESC");

		Page<Record> pages = Db.paginate(MapUtils.getInteger(param, "pageNumber"),
				MapUtils.getInteger(param, "pageSize"), select.toString(), from.toString());
		return new BTResult<Record>(pages.getTotalRow(), pages.getList());
	}

	/**
	 * 新增/修改用户角色
	 * 
	 * @param param
	 * @return
	 * @Author: Brin
	 * @Date: 2015年11月20日 上午11:55:12
	 */
	@Before(Tx.class)
	public IResult<Object> role(Map<String, Object> param) {
		try {
			// 删除用户所有角色
			Db.update("DELETE FROM base_object_user_relation WHERE userId = ?", MapUtils.getIntValue(param, "userId"));
			// 重新新增用户角色
			if (StringUtils.isNoneBlank(MapUtils.getString(param, "roleIds"))) {
				String[] roleIds = MapUtils.getString(param, "roleIds").split(",");
				for (String roleId : roleIds) {
					Db.update("INSERT INTO base_object_user_relation(category, objectId, userId) VALUES(?, ?, ?)", 1,
							roleId, MapUtils.getIntValue(param, "userId"));
				}
				// Object[][] paras = new Object[userIds.length][3];
				// for (int i = 0; i < userIds.length; i++) {
				// paras[i][0] = 1; // 1：角色 2：群组
				// paras[i][1] = MapUtils.getIntValue(param, "roleId");
				// paras[i][2] = userIds[i];
				// }
				// Db.batch("INSERT INTO base_object_user_relation(category, objectId, userId) VALUES(?, ?, ?)", paras,
				// 1000);
			}
			return Result.createSuccess();
		} catch (Exception e) {
			throw new RuntimeException("用户角色异常！", e);
		}
	}

	/**
	 * 验证用户名是否存在
	 * 用于jquery.validate的remote验证
	 * 
	 * @param username
	 * @return
	 * @Author: Brin
	 * @Date: 2015年11月10日 下午12:02:34
	 */
	public Boolean validateUsername(User user) {
		StringBuffer sql = new StringBuffer(
				"SELECT id FROM ww_user WHERE username = '" + user.getStr("username") + "'");
		if (null != user.getInt("id")) {
			sql.append(" AND id <> " + user.getInt("id"));
		}
		List<User> list = User.me.find(sql.toString());
		return CollectionUtils.isEmpty(list);
	}

	/**
	 * 对密码进行加密
	 * 
	 * @param user
	 * @Author: Brin
	 * @Date: 2015年11月10日 下午5:49:20
	 */
	private void encryptedPassword(User user) {
		// 密码加密
		byte[] salt = Digests.generateSalt(8);
		user.set("salt", Encodes.encodeHex(salt));
		byte[] hashPassword = Digests.sha1(user.getStr("password").getBytes(), user.getStr("salt").getBytes(), 1024);
		user.set("password", Encodes.encodeHex(hashPassword));
	}
}
